/**
 * 
 */
package com.cssy.yd.logic.service.impl;

import java.util.Date;
import java.util.List;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.alibaba.fastjson.JSONArray;
import com.byd.acegiext.domain.User;
import com.cssy.yd.logic.dao.LogicSoDAO;
import com.cssy.yd.logic.dao.LogicSoItemDAO;
import com.cssy.yd.logic.dao.LogicSoWareDAO;
import com.cssy.yd.logic.dao.LogicSoWareItemDAO;
import com.cssy.yd.logic.dao.LogicSoWarefreezeDAO;
import com.cssy.yd.logic.dao.LogicSoWarefreezeItemDAO;
import com.cssy.yd.logic.dao.LogicSoWarefreezedealDAO;
import com.cssy.yd.logic.dao.LogicSoWarefreezedealItemBatchDAO;
import com.cssy.yd.logic.dao.LogicSoWarefreezedealItemDAO;
import com.cssy.yd.logic.dao.LogicSoWareunfreezeDAO;
import com.cssy.yd.logic.dao.LogicSoWareunfreezeItemBatchDAO;
import com.cssy.yd.logic.dao.LogicSoWareunfreezeItemDAO;
import com.cssy.yd.logic.entity.LogicSoDO;
import com.cssy.yd.logic.entity.LogicSoItemDO;
import com.cssy.yd.logic.entity.LogicSoReturnItemBatchDO;
import com.cssy.yd.logic.entity.LogicSoReturnItemDO;
import com.cssy.yd.logic.entity.LogicSoWarefreezeDO;
import com.cssy.yd.logic.entity.LogicSoWarefreezeItemDO;
import com.cssy.yd.logic.entity.LogicSoWarefreezedealDO;
import com.cssy.yd.logic.entity.LogicSoWarefreezedealItemBatchDO;
import com.cssy.yd.logic.entity.LogicSoWarefreezedealItemDO;
import com.cssy.yd.logic.entity.LogicSoWareunfreezeDO;
import com.cssy.yd.logic.entity.LogicSoWareunfreezeItemBatchDO;
import com.cssy.yd.logic.entity.LogicSoWareunfreezeItemDO;
import com.cssy.yd.logic.entity.LogicWhAffDO;
import com.cssy.yd.logic.service.ILogicSoWareunfreezeService;
import com.cssy.yd.logic.service.ILogicWhAffStockService;
import com.cssy.yd.logic.util.MathUtil;
import com.cssy.yd.logic.util.logic.LogicSoBeanUtil;
import com.plat.exception.SyBaseException;
import com.plat.helper.SearchCondition;
import com.plat.helper.SearchConditions;
import com.plat.helper.SearchResult;
import com.plat.util.DateUtils;
import com.plat.util.GlobalResLoader;
import com.plat.util.IDCodeTypeUtil;
import com.plat.util.SessionUtil;
import com.yuendong.sy.po.code.SyCode;
import com.yuendong.sy.service.code.SyCodeType;
import com.yuendong.sy.service.code.impl.SyCodeService;

/**
 * @author huang.xuming [2013-8-19]
 *
 */
@Service("logicSoWareunfreezeService")
public class LogicSoWareunfreezeServiceImpl implements ILogicSoWareunfreezeService {
	private static final Logger logger = Logger.getLogger(LogicSoWareunfreezeServiceImpl.class);
	
	@Resource(name = "logicSoWareunfreezeDAO")
	private LogicSoWareunfreezeDAO logicSoWareunfreezeDAO;
	
	@Resource(name = "logicSoWareunfreezeItemDAO")
	private LogicSoWareunfreezeItemDAO logicSoWareunfreezeItemDAO;
	
	@Resource(name = "logicSoWarefreezeDAO")
	private LogicSoWarefreezeDAO logicSoWarefreezeDAO;
	
	@Resource(name = "logicSoWarefreezeItemDAO")
	private LogicSoWarefreezeItemDAO logicSoWarefreezeItemDAO;
	
	@Resource(name = "logicSoWarefreezedealDAO")
	private LogicSoWarefreezedealDAO logicSoWarefreezedealDAO;
	
	@Resource(name = "logicSoWarefreezedealItemDAO")
	private LogicSoWarefreezedealItemDAO logicSoWarefreezedealItemDAO;
	
	@Resource(name = "logicSoWareDAO")
	private LogicSoWareDAO logicSoWareDAO;

	@Resource(name = "logicSoWareItemDAO")
	private LogicSoWareItemDAO logicSoWareItemDAO;
	
	@Resource(name = "logicSoDAO")
	private LogicSoDAO logicSoDAO;
	
	@Resource(name = "logicSoItemDAO")
	private LogicSoItemDAO logicSoItemDAO;
	
	@Resource(name = "logicWhAffStockService")
	private ILogicWhAffStockService logicWhAffStockService;
	
	@Resource(name = "syCodeService")
	private SyCodeService syCodeService;
	
	@Resource(name="logicSoWareunfreezeItemBatchDAO")
	private LogicSoWareunfreezeItemBatchDAO logicSoWareunfreezeItemBatchDAO;
	
	@Resource(name="logicSoWarefreezedealItemBatchDAO")
	private LogicSoWarefreezedealItemBatchDAO logicSoWarefreezedealItemBatchDAO;
	
	@Override
	public SearchResult findListByExample(SearchConditions scs)
			throws SyBaseException {
		SearchResult rs=new SearchResult(scs);
		List<LogicSoWareunfreezeDO> list=logicSoWareunfreezeDAO.find(scs);
		rs.setRecordCount(logicSoWareunfreezeDAO.count(scs));
		rs.setResults(list);
		return rs;
	}

	@Override
	public Integer delete(String id, User user) throws SyBaseException {
		return logicSoWareunfreezeDAO.deleteLogicSoWareunfreezeDOByPrimaryKey(id);
	}

	@Override
	@Transactional
	public Integer update(LogicSoWareunfreezeDO t, User user)
			throws SyBaseException {
		t.setDuuser(user.getName());
		t.setDutime(new Date());
		return logicSoWareunfreezeDAO.updateLogicSoWareunfreezeDO(t);
	}

	@Override
	@Transactional
	public LogicSoWareunfreezeDO save(LogicSoWareunfreezeDO t, User user)
			throws SyBaseException {
		t.setDcruser(user.getName());
		t.setDctime(new Date());
		logicSoWareunfreezeDAO.insertLogicSoWareunfreezeDO(t);
		return t;
	}

	@Override
	public LogicSoWareunfreezeDO findListById(String id) throws SyBaseException {
		return logicSoWareunfreezeDAO.findLogicSoWareunfreezeDOByPrimaryKey(id);
	}
	
	
	@Override
	public void soWareunfreezeSave(HttpServletRequest request,
			LogicSoWareunfreezeDO curAP) throws SyBaseException {
		try {
			String itemdata = request.getParameter("itemdata");
			List<LogicSoWareunfreezeItemDO> swfItemlist = JSONArray.parseArray(itemdata,
					LogicSoWareunfreezeItemDO.class);
			
			/*
			 * 获取操作
			 * 0为保存(草稿状态)
			 * 1为提交(待审核状态)
			 * 2为二级结案(提交二级结案)
			 * 3为二级驳回到草稿
			 * 4为拟稿人取消订单
			 */
			String paramflag = request.getParameter("paramflag");
			int iToFlag = -1;
			iToFlag = Integer.parseInt(paramflag);
			curAP.setBillstatus(Integer.parseInt(paramflag));
			
			User user = SessionUtil.getUser(request);
			Date curDate = new Date();
			
			
			if (StringUtils.isBlank(curAP.getId())) {
				/* 新增  设置状态billstatus= 0*/
				
				//---start 判断单据是否存在未完成处理的记录
				if(StringUtils.isBlank(curAP.getSowarefreedealNo())){
					throw new SyBaseException("销售冻结处理单编号参数为空");
				}
				SearchConditions soScs = new SearchConditions();
				soScs.addCondition("sowarefreedeal_no", curAP.getSowarefreedealNo(), SearchCondition.OP_EQUAL);
				soScs.addCondition("billstatus", "2", SearchCondition.OP_NOTEQUAL);
				soScs.addCondition("billstatus", "4", SearchCondition.OP_NOTEQUAL);
				Integer count = logicSoWareunfreezeDAO.count(soScs);
				if(null != count && count > 0){
					throw new SyBaseException(curAP.getSoNo()+"销售冻结处理单存在未处理的销售解冻单");
				}
				//---end 判断单据是否存在未完成处理的记录
				
				String id = IDCodeTypeUtil.getId();
				curAP.setId(id);
				curAP.setDctime(curDate);
				curAP.setDcruser(user.getName());
				
				curAP.setLister(user.getName());
				curAP.setListerName(user.getRealName());
				
				
				curAP.setNo(syCodeService.getCode("SJ","SJ",SyCode.DATE_YYMM,5));
				
				//日期转换处理
				String receipDate = request.getParameter("receipDate");
				if(StringUtils.isNotBlank(receipDate)){
					curAP.setReceipDate(DateUtils.stringToDate(receipDate));
				}
				String deliveryDate = request.getParameter("deliveryDate");
				if(StringUtils.isNotBlank(deliveryDate)){
					curAP.setDeliveryDate(DateUtils.stringToDate(deliveryDate));
				}
				
				logicSoWareunfreezeDAO.insertLogicSoWareunfreezeDO(curAP);
				
				curAP.setId(id);//添加上，否则插入之后ID为0
				saveOrUpdateItems(swfItemlist, curAP);
				
				
			} else if(iToFlag >= 0 && iToFlag <=4){
				/* 修改 */
				LogicSoWareunfreezeDO bean=logicSoWareunfreezeDAO.findLogicSoWareunfreezeDOByPrimaryKey(curAP.getId());
				if(null == bean.getVersion() || !bean.getVersion().equals(curAP.getVersion())){
					throw new SyBaseException("版本号异常，请刷新后重新编辑");
				}
				
				bean.setBillstatus(iToFlag);
				
				int result = 0;
				if(1==iToFlag ){//2为二级审核(提交二级审核)
					curAP.setBillstatus(bean.getBillstatus());
					
					curAP.setDctime(bean.getDctime());
					curAP.setDcruser(bean.getDcruser());
					
					curAP.setLister(user.getName());
					curAP.setListerName(user.getRealName());
					curAP.setDutime(curDate);
					curAP.setDuuser(user.getName());
					
					//日期转换处理
					String receipDate = request.getParameter("receipDate");
					if(StringUtils.isNotBlank(receipDate)){
						curAP.setReceipDate(DateUtils.stringToDate(receipDate));
					}
					String deliveryDate = request.getParameter("deliveryDate");
					if(StringUtils.isNotBlank(deliveryDate)){
						curAP.setDeliveryDate(DateUtils.stringToDate(deliveryDate));
					}
					
					result =logicSoWareunfreezeDAO.updateLogicSoWareunfreezeDO(curAP);
					if(result==1){
						saveOrUpdateItems(swfItemlist, curAP);
					}
				}else if(2==iToFlag ){//2二级结案(提交二级结案)
					/*
					 * 解冻处理：
					 * 
					 *  全部解冻标记=true
					 *  
					 *  获取销售订单DO
					 *  获取销售订单item
					 *  获取订单DO
					 *  //if(出库单.冻结状态 )
					 *  if(订单DO.冻结标记==未冻结or全部解冻){
					 *  	异常
					 *  }
					 *  
					 *  for(销售订单item){
					 *  	for(当前解冻单item){
					 *  		if(销售订单item当前项.产品编码 == 当前解冻单item.产品编码){//相应
					 *  			if(销售订单item当前项.冻结数量 > 当前解冻单item.申请解冻数量){
					 *  				全部解冻标记=false;
					 *  			}if else(销售订单item当前项.冻结数量 < 当前解冻单item.申请解冻数量){
					 *  				异常
					 *  			}
					 *  			
					 *  			销售订单item当前项.冻结数量 -= 当前解冻单item.申请解冻数量;
					 *  
					 *  			持久化出库单item
					 *  			持久化当前解冻单item
					 *  
					 *  			可用库存加，冻结库存减
					 *  		}
					 *  	}
					 *  
					 *  	if(冻结数量大于0){
					 *  		全部解冻标记=false;
					 *  	}
					 *  }
					 *  
					 *  if(全部解冻标记==true){
					 *  	订单DO.冻结标记=全部出库
					 *  }
					 *  
					 *  持久化当前解冻单DO
					 *  
					 */
					
					
					boolean isSoFullUnfrozen = true;
					boolean isSwfFullUnfrozen = true;
					boolean isSwfdFullUnfrozen = true;
					
					SearchConditions scs1 = new SearchConditions();
					scs1.addCondition("no", curAP.getSoNo(), SearchCondition.OP_EQUAL);
					List<LogicSoDO> soList = logicSoDAO.find(scs1);
					if(null ==soList || soList.size() == 0 ){
						throw new SyBaseException(curAP.getSoNo()+"销售单号不存在");
					}
					LogicSoDO soDo = soList.get(0);
					List<LogicSoItemDO> soItemList = logicSoItemDAO.findItemListBysoId(soDo.getId());
					if(null == soItemList){
						throw new SyBaseException(curAP.getSoNo()+"销售单Item不存在");
					}
					
					//冻结申请单bean 
					SearchConditions scs2 = new SearchConditions();
					scs2.addCondition("no", curAP.getSowarefreeNo(), SearchCondition.OP_EQUAL);
					List<LogicSoWarefreezeDO> sowfDOList= logicSoWarefreezeDAO.find(scs2);
					if(null == sowfDOList || 0 == sowfDOList.size() ){
						throw new SyBaseException(curAP.getSowarefreeNo()+"冻结申请单号不存在");
					}
					LogicSoWarefreezeDO sowfDO = sowfDOList.get(0);
					//冻结申请单item
					List<LogicSoWarefreezeItemDO> sowfItemList= logicSoWarefreezeItemDAO.findItemListBySoWareFreezeId(sowfDO.getId());
					if(null == sowfItemList || 0 == sowfItemList.size() ){
						throw new SyBaseException(curAP.getSowarefreeNo()+"冻结申请单号的item不存在");
					}
					
					//冻结处理单bean 
					SearchConditions scs3 = new SearchConditions();
					scs3.addCondition("no", curAP.getSowarefreedealNo(), SearchCondition.OP_EQUAL);
					List<LogicSoWarefreezedealDO> sowfdDOList= logicSoWarefreezedealDAO.find(scs3);
					if(null == sowfdDOList || 0 == sowfdDOList.size() ){
						throw new SyBaseException(curAP.getSowarefreeNo()+"冻结处理单号不存在");
					}
					LogicSoWarefreezedealDO sowfdDO = sowfdDOList.get(0);
					//冻结处理单item
					List<LogicSoWarefreezedealItemDO> sowfdItemList= logicSoWarefreezedealItemDAO.findItemListByswfdId(sowfdDO.getId());
					if(null == sowfdItemList || 0 == sowfdItemList.size() ){
						throw new SyBaseException(curAP.getSowarefreeNo()+"冻结处理单号的item不存在");
					}
					
					//解冻单据item
					for(LogicSoWareunfreezeItemDO curSwfItem : swfItemlist){
						double jdBQty = curSwfItem.getSqjdBQuantity();
						double jdQty = curSwfItem.getSqjdQuantity();//MathUtil.mathUtil.divide(jdBQty, curSwfItem.getProdUnitConvert());
						
						//销售订单item
						for(LogicSoItemDO curSoItem : soItemList){
							if(curSwfItem.getProdNo().equals(curSoItem.getProdNo())
									&& curSwfItem.getStatus().equals(curSoItem.getStatus())
									){
								//可解冻数量
								if(0 > curSoItem.getFrozenBQuantity()-jdBQty){
									throw new SyBaseException("销售订单单号"+curAP.getSoNo()+".产品编码"+curSoItem.getProdNo()+"，等级"+curSoItem.getStatus()+"的冻结基本数量（"+curSoItem.getFrozenBQuantity()+"）不足");
								}
								
								//冻结数量减少
								curSoItem.setFrozenBQuantity(curSoItem.getFrozenBQuantity()-jdBQty);
								curSoItem.setFrozenQuantity(curSoItem.getFrozenQuantity()-jdQty);
								logicSoItemDAO.updateLogicSoItemDO(curSoItem);
								//break;
							}
						}
						
						//销售冻结申请单item
						for(LogicSoWarefreezeItemDO cursfItem : sowfItemList){
							if(curSwfItem.getProdNo().equals(cursfItem.getProdNo())
									&& curSwfItem.getStatus().equals(cursfItem.getStatus())
									){
								//可解冻数量
								if(LogicSoBeanUtil.getInstance().calcFreezeItemCanUnfreezeBQty(cursfItem) < jdBQty){
									throw new SyBaseException(sowfDO.getNo()+"冻结申请单的可解冻数量不足--"+LogicSoBeanUtil.getInstance().calcFreezeItemCanUnfreezeBQty(cursfItem));
								}
								
								//解冻数量增大
								cursfItem.setSjdjJdBQty(cursfItem.getSjdjJdBQty()+jdBQty);
								cursfItem.setSjdjJdQty(cursfItem.getSjdjJdQty()+jdQty);
								
								logicSoWarefreezeItemDAO.updateLogicSoWarefreezeItemDO(cursfItem);
							}
						}
						
						//销售冻结处理单item
						for(LogicSoWarefreezedealItemDO cursfItem : sowfdItemList){
							if(curSwfItem.getProdNo().equals(cursfItem.getProdNo())
									&& curSwfItem.getStatus().equals(cursfItem.getStatus())
									&& curSwfItem.getProdBatch().equals(cursfItem.getProdBatch())
									//curAP.getWhcode() 相同仓库
									){
								//可解冻数量
								double canJdBQty = cursfItem.getDjBQuantity() - cursfItem.getDjckBQuantity() - cursfItem.getDjjdBQuantity();
								if(jdBQty < canJdBQty){
									isSwfdFullUnfrozen = false;
								}else if(jdBQty > canJdBQty){
									throw new SyBaseException("冻结处理单号"+curAP.getSowarefreedealNo()+".产品编码"+cursfItem.getProdNo()+"，等级"+cursfItem.getStatus()+"的可解冻基本数量（"+canJdBQty+"）不足");
								}
								
								//解冻数量增加
								List<LogicSoWareunfreezeItemBatchDO> unfreezeBatchDOs = null;
								if(curSwfItem.getItemBatch() != null && !"".equals(curSwfItem.getItemBatch().trim())){
									 unfreezeBatchDOs = JSONArray.parseArray(curSwfItem.getItemBatch(),LogicSoWareunfreezeItemBatchDO.class);
								}
								List<LogicSoWarefreezedealItemBatchDO> freezedealItemBatch=null;
								if(unfreezeBatchDOs!=null){
									 freezedealItemBatch= logicSoWarefreezedealItemBatchDAO.findBywfdId(cursfItem.getId());
									for (LogicSoWarefreezedealItemBatchDO fBatchDO : freezedealItemBatch) {
										for (LogicSoWareunfreezeItemBatchDO uBatchDO : unfreezeBatchDOs) {
											if(fBatchDO.getProdNo().equals(uBatchDO.getProdNo()) && fBatchDO.getProdBatch().equals(uBatchDO.getProdBatch())&&fBatchDO.getStatus().equals(uBatchDO.getStatus())){
												fBatchDO.setDjjdBQuantity((fBatchDO.getDjjdBQuantity()==null?0.0:fBatchDO.getDjjdBQuantity())+uBatchDO.getSqjdBQuantity());
												fBatchDO.setDjjdQuantity((fBatchDO.getDjjdQuantity()==null?0.0:fBatchDO.getDjjdQuantity())+uBatchDO.getSqjdQuantity());
											}
										}
										logicSoWarefreezedealItemBatchDAO.updateLogicSoWarefreezedealItemBatchDO(fBatchDO);
									}
								}
								if(freezedealItemBatch!=null){
									cursfItem.setItemBatch(JSONArray.toJSONString(freezedealItemBatch));
								}
								cursfItem.setDjjdBQuantity(cursfItem.getDjjdBQuantity()+jdBQty);
								cursfItem.setDjjdQuantity(cursfItem.getDjjdQuantity()+jdQty);
								logicSoWarefreezedealItemDAO.updateLogicSoWarefreezedealItemDO(cursfItem);
							}
						}
						
						/* 解冻库存处理 */
						unfreezeWhAff(curAP, curSwfItem, user,jdQty, jdBQty);
						
					}
					
					//冻结处理冻结标记
					for(LogicSoWarefreezedealItemDO cursfdItem : sowfdItemList){
						if(LogicSoBeanUtil.getInstance().calcFreezeDealItemCanUnfreezeBQty(cursfdItem) > 0){
							isSwfdFullUnfrozen = false;
						}
					}
					
					//冻结申请冻结标记
					for(LogicSoWarefreezeItemDO cursfItem : sowfItemList){
						if(LogicSoBeanUtil.getInstance().calcFreezeItemCanUnfreezeBQty(cursfItem) > 0){
							isSwfFullUnfrozen = false;
						}
					}
					
					
					//销售订单冻结标记处理
					for(LogicSoItemDO curSoItem : soItemList){
						if(curSoItem.getFrozenBQuantity() > 0){
							isSoFullUnfrozen = false;
						}
					}
					
					if(true == isSoFullUnfrozen){
						soDo.setFrozenStatus(0);//全部解冻
						if(true != isSwfFullUnfrozen){
							logger.error(sowfDO.getNo()+"销售冻结申请单未全部解冻，而销售订单已全部解冻");
						}
						if(true != isSwfdFullUnfrozen){
							logger.error(sowfdDO.getNo()+"销售冻结处理单未全部解冻，而销售订单已全部解冻");
						}
//						isSwfFullUnfrozen = true;
					}else{
						soDo.setFrozenStatus(2);//部分解冻
					}
					//持久化订单单据
					logicSoDAO.updateLogicSoDO(soDo);
					
					//持久化冻结申请单据
					if(true == isSwfFullUnfrozen){
						sowfDO.setFrozenStatus(4);
						if(true != isSwfdFullUnfrozen){
							logger.error(sowfdDO.getNo()+"销售冻结处理单未全部解冻，而销售订单已全部解冻");
						}
//						isSwfdFullUnfrozen = true;
						//不需要回馈冻结状态给冻结申请单，以免持续部分冻结而完全解冻的，无法继续冻结。
						//但是完全出库的必须设置为完全解冻！
//						logicSoWarefreezeDAO.updateLogicSoWarefreezeDO(sowfDO);
					}
					
					
					//持久化冻结处理单据
					if(true == isSwfdFullUnfrozen){
						sowfdDO.setUnfrozenStatus(2);//全部解冻
					}else{
						sowfdDO.setUnfrozenStatus(1);//部分解冻
					}
					logicSoWarefreezedealDAO.updateLogicSoWarefreezedealDO(sowfdDO);
					
					
					//持久化解冻单据
					bean.setAuditor(user.getName());//二级
					bean.setAuditorName(user.getRealName());
					result =logicSoWareunfreezeDAO.updateLogicSoWareunfreezeDO(bean);
					
				}else if(3==iToFlag){//3为二级驳回到草稿
					
					bean.setAuditor(user.getName());//二级
					bean.setAuditorName(user.getRealName());
					result =logicSoWareunfreezeDAO.updateLogicSoWareunfreezeDO(bean);
				}else if(4==iToFlag){//4为取消订单 
					bean.setDutime(bean.getDctime());
					bean.setDuuser(bean.getDcruser());
					result =logicSoWareunfreezeDAO.updateLogicSoWareunfreezeDO(bean);
					
				}
				if(result==0){
					throw new SyBaseException("您修改的行数据发生改变，请重新点开查看");
				}
				
			}else{
				throw new SyBaseException("ParamFlag不合法："+iToFlag);
			}
			
		} catch (Exception e) {
			//e.printStackTrace();
			logger.error(e.getMessage(), e);
			throw new SyBaseException(GlobalResLoader.getOpfailed()
					+ e.getMessage(), e);
		}
	}

	/**
	 * 单据的子项持久化
	 * @param soItemlist
	 * @param curAP
	 */
	private void saveOrUpdateItems(List<LogicSoWareunfreezeItemDO> soItemlist ,LogicSoWareunfreezeDO curAP){
		//删除本订单下的item
				if(null != curAP.getId()){
					List<LogicSoWareunfreezeItemDO> unItemDOs = logicSoWareunfreezeItemDAO.findItemListBySoWareUnfreezeId(curAP.getId());
					if(unItemDOs != null){
						for (int i = 0; i < unItemDOs.size(); i++) {
							logicSoWareunfreezeItemBatchDAO.deleteBywareItemfreezeId(unItemDOs.get(i).getId());
							
						}
					}
					logicSoWareunfreezeItemDAO.deleteLogicSoWarefreezeItemDOBySoWareUnfreezeId(curAP.getId());
				}
				
				//插入单据的item
				if(null != soItemlist){
					for (LogicSoWareunfreezeItemDO soItemDO : soItemlist) {
						//对需要处理的item进行赋值
						String unItemId = IDCodeTypeUtil.getId();
						soItemDO.setId(unItemId);
						soItemDO.setWarefreezeId(curAP.getId());
						soItemDO.setSoNo(curAP.getNo());
						soItemDO.setCliNo(curAP.getCliNo());
						soItemDO.setCliName(curAP.getCliName());
						
						
						logicSoWareunfreezeItemDAO.insertLogicSoWareunfreezeItemDO(soItemDO);
						if(soItemDO.getItemBatch() != null && !"".equals(soItemDO.getItemBatch())){
							List<LogicSoWareunfreezeItemBatchDO> itemBatchDOs = JSONArray.parseArray(soItemDO.getItemBatch(),LogicSoWareunfreezeItemBatchDO.class);
							for (int i = 0; i < itemBatchDOs.size(); i++) {
								itemBatchDOs.get(i).setId(IDCodeTypeUtil.getId());
								itemBatchDOs.get(i).setWareitemfreezeId(unItemId);
								logicSoWareunfreezeItemBatchDAO.insertLogicSoWareunfreezeItemBatchDO(itemBatchDOs.get(i));
							}
					}
					}
				}
	}
	
//	/**
//	 * 
//	 * @param soNo
//	 * @param freezeStatus
//	 */
//	private void updateSoFreezeStatus(String soNo,Integer freezeStatus){
//		SearchConditions scs = new SearchConditions();
//		scs.addCondition("no", soNo, SearchCondition.OP_EQUAL);
//		List<LogicSoDO> soList = logicSoDAO.find(scs);
//		if(null != soList && soList.size() > 0){
//			LogicSoDO so = soList.get(0);
//			LogicSoDO logicSoDO = new LogicSoDO();
//			logicSoDO.setId(so.getId());
//			logicSoDO.setFrozenStatus(freezeStatus);
//			logicSoDAO.updateLogicSoDO(logicSoDO);
//		}else{
//			String msg = soNo+"编号的销售订单查找失败，销售订单冻结标记修改失败。";
//			logger.error(msg);
//			throw new SyBaseException(msg);
//		}
//	}

	@Override
	@Transactional
	public Integer updateToDelete(LogicSoWareunfreezeDO t, User user)
			throws SyBaseException {
		t.setDuuser(user.getName());
		t.setDutime(new Date());
		
		// 修改销售订单冻结标记-冻结
//		updateSoFreezeStatus(t.getSoNo(),1);
		
		return logicSoWareunfreezeDAO.updateLogicSoWareunfreezeDO(t);
	}



	@Override
	public List<LogicSoWareunfreezeItemDO> findItemListBysowareunfreezeId(
			String sowareunfreezeId) {
		List<LogicSoWareunfreezeItemDO> list = logicSoWareunfreezeItemDAO.findItemListBySoWareUnfreezeId(sowareunfreezeId);
        return list;
	}


	/**
	 * 解冻库存处理
	 * @param curAP
	 * @param sowfdItem
	 * @param user
	 * @param quantity
	 * @param jquantity
	 */
	private void unfreezeWhAff(LogicSoWareunfreezeDO curAP,LogicSoWareunfreezeItemDO sowfdItem,User user,double quantity,double jquantity){
//		Double jquantity = MathUtil.mathUtil.multiply(quantity, sowfdItem.getProdUnitConvert());
		
		//判断冻结库存是否充足
		if("Y".equals(sowfdItem.getOpenBatch())){
			if(sowfdItem.getItemBatch() != null && !"".equals(sowfdItem.getItemBatch().trim())){
				List<LogicSoWareunfreezeItemBatchDO> itemBatchDOs = JSONArray.parseArray(sowfdItem.getItemBatch(),LogicSoWareunfreezeItemBatchDO.class);
				for (int i = 0; i < itemBatchDOs.size(); i++) {
					boolean ifEnough = logicWhAffStockService
							.validateStorageQuaitity(sowfdItem.getProdNo(), curAP.getWhcode(), sowfdItem.getHubcode(), "4", itemBatchDOs.get(i).getProdBatch(), itemBatchDOs.get(i).getSqjdBQuantity());
					if(!ifEnough){
						throw new SyBaseException(sowfdItem.getProdNo()+"产品，冻结库存不足"+itemBatchDOs.get(i).getSqjdBQuantity());
					}
			
				LogicWhAffDO lwhaff = new LogicWhAffDO();
				lwhaff.setBillCode(curAP.getNo());
				lwhaff.setBillType("SJ");// 设置为销售解冻编码的头字符，供报表使用
				lwhaff.setWhCode(curAP.getWhcode());
				lwhaff.setWhname(curAP.getWhname());
				lwhaff.setBatch(itemBatchDOs.get(i).getProdBatch());
				lwhaff.setUnit(sowfdItem.getProdUnit());
				lwhaff.setJunit(sowfdItem.getProdBUnit());
				if(null != sowfdItem.getProdPrice()){
					lwhaff.setPrice(Double.valueOf(sowfdItem.getProdPrice().toString()));
				}
				lwhaff.setCode(sowfdItem.getProdNo());
				lwhaff.setName(sowfdItem.getProdName());
				lwhaff.setSpec(sowfdItem.getProdSpecDesc());
				lwhaff.setBrand(sowfdItem.getProdModel());
				lwhaff.setHubCode(sowfdItem.getHubcode());
				lwhaff.setHubName(sowfdItem.getHubname());
				lwhaff.setStatus(itemBatchDOs.get(i).getStatus());// 
				lwhaff.setQuantity(itemBatchDOs.get(i).getSqjdQuantity());
				lwhaff.setJquantity(itemBatchDOs.get(i).getSqjdBQuantity());
				/*可用库存添加*/
				logicWhAffStockService.updateWhAffstockQuantity(lwhaff,user,false);
				
				
				/*冻结库存减少*/
				lwhaff.setStatus("4");// 冻结仓库
				//lwhaff.setRemark(sowfdItem.getStatus());//
				lwhaff.setQuantity(-itemBatchDOs.get(i).getSqjdQuantity());// 减少库存
				lwhaff.setJquantity(-itemBatchDOs.get(i).getSqjdBQuantity());//减少库存
				logicWhAffStockService.updateWhAffstockQuantity(lwhaff,user,false);
				}
			}
		}else{
			boolean ifEnough = logicWhAffStockService
					.validateStorageQuaitity(sowfdItem.getProdNo(), curAP.getWhcode(), sowfdItem.getHubcode(), "4", "NoBatch", jquantity);
			if(!ifEnough){
				throw new SyBaseException(sowfdItem.getProdNo()+"产品，冻结库存不足"+jquantity);
			}
	
		LogicWhAffDO lwhaff = new LogicWhAffDO();
		lwhaff.setBillCode(curAP.getNo());
		lwhaff.setBillType("SJ");// 设置为销售解冻编码的头字符，供报表使用
		lwhaff.setWhCode(curAP.getWhcode());
		lwhaff.setWhname(curAP.getWhname());
		lwhaff.setBatch("NoBatch");
		lwhaff.setUnit(sowfdItem.getProdUnit());
		lwhaff.setJunit(sowfdItem.getProdBUnit());
		if(null != sowfdItem.getProdPrice()){
			lwhaff.setPrice(Double.valueOf(sowfdItem.getProdPrice().toString()));
		}
		lwhaff.setCode(sowfdItem.getProdNo());
		lwhaff.setName(sowfdItem.getProdName());
		lwhaff.setSpec(sowfdItem.getProdSpecDesc());
		lwhaff.setBrand(sowfdItem.getProdModel());
		lwhaff.setHubCode(sowfdItem.getHubcode());
		lwhaff.setHubName(sowfdItem.getHubname());
		lwhaff.setStatus(sowfdItem.getStatus());// 
		lwhaff.setQuantity(quantity);
		lwhaff.setJquantity(jquantity);
		/*可用库存添加*/
		logicWhAffStockService.updateWhAffstockQuantity(lwhaff,user,false);
		
		
		/*冻结库存减少*/
		lwhaff.setStatus("4");// 冻结仓库
		//lwhaff.setRemark(sowfdItem.getStatus());//
		lwhaff.setQuantity(-quantity);// 减少库存
		lwhaff.setJquantity(-jquantity);//减少库存
		logicWhAffStockService.updateWhAffstockQuantity(lwhaff,user,false);
		}
		
	}

	@Override
	public Integer deleteBizRemoved(String id) throws SyBaseException {
		// TODO Auto-generated method stub
		return null;
	}
	

}
